home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 …SCII & the Runetime Code / ADC Developer CD (1992-07) (''Butch ASCII And The Runtime Code'')_iso / Dev.CD 199207.iso / Tools & Apps / Devices & Hardware / A⁄ROSE / MessageDispatcher / DemoMesDis.c next >
Encoding:
C/C++ Source or Header  |  1991-05-03  |  6.7 KB  |  273 lines  |  [TEXT/MPS ]
  1. /*
  2.     Program to test Message Dispatcher
  3.     
  4.     Written by:    Anumele D. Raja
  5.     
  6.     Date:        Arpil 19, 1991
  7.     
  8.     Copyright @ Apple Computer, Inc.  1991
  9.     
  10.     This program tests the Message Dispatcher code.
  11.     
  12.     Opens main queue and secondary queue.
  13.     Sets up receive completion for N mCodes starting from 0 in steps of 2
  14.     Then uses the secondary queue to send messages to main queue with
  15.         N mCodes starting from 0 in steps of 2.
  16.     Sets up N completion routines to wait for replies in the secondary queue.
  17.         These completion routines will set flags in the global area
  18.         
  19.     Modification History:
  20.     
  21.     04/30/91    Raja    Added code to test Dispatch calls in main thread itself
  22.     
  23. */
  24.  
  25. #include <StdIO.h>
  26. #include <CursorCtl.h>
  27. #include <StdLib.h>
  28. #include <Events.h>
  29.  
  30. #include "MultiThread.h"
  31. #include "MessageDispatcher.h"
  32.  
  33. #define        N    8
  34. #define    kNoOfMessages    16
  35. #define    CODE_OFFSET    200
  36.  
  37. enum { kFalse, kTrue };
  38.  
  39. // Function declarations
  40.  
  41. void MainReceive(mMessage *msgPtr);
  42. void SecReceive0(mMessage *msgPtr);
  43. void SecReceive1(mMessage *msgPtr);
  44. void SecReceive2(mMessage *msgPtr);
  45. void SecReceive3(mMessage *msgPtr);
  46. void SecReceive4(mMessage *msgPtr);
  47. void SecReceive5(mMessage *msgPtr);
  48. void SecReceive6(mMessage *msgPtr);
  49. void SecReceive7(mMessage *msgPtr);
  50.  
  51. mMessage *msgRecd[N];
  52. QueueEntry *secQPtr;
  53.  
  54. static    char        object_name [] = "echo manager";
  55. static    char        type_name []   = "echo manager";
  56.  
  57. main()
  58. {
  59.     tid_type mainTID, secTID, echoTID;
  60.     int i;
  61.     char done;
  62.     mMessage *msgPtr;
  63.     unsigned short index;
  64.     
  65.     if (!(mainTID = OpenQueue(0))) {
  66.         printf("*** Cannot open main queue ***\n");
  67.         exit(1);
  68.     }
  69.         
  70.     if (!(secQPtr = CreateQueue())) {
  71.         printf("*** Cannot create secondary queue ***\n");
  72.         exit(1);
  73.     }
  74.     
  75.     if (!(secTID = secQPtr->OpenQueue(0))) {
  76.         printf("*** Cannot open secondary queue ***\n");
  77.         exit(1);
  78.     }
  79.  
  80.     index = 0;
  81.     
  82.     echoTID = Lookup_Task(object_name, type_name, GetNameTID(), &index);
  83.     printf("Echo TID for main thread %d\n", echoTID);
  84.     printf("Name manager TID for main thread %d\n", GetNameTID());
  85.     index = 0;
  86.     
  87.     echoTID = secQPtr->Lookup_Task(object_name, type_name, secQPtr->GetNameTID(), &index);
  88.     printf("Echo TID for secondary thread %d\n", echoTID);
  89.     printf("Name manager TID for secondary thread %d\n", secQPtr->GetNameTID());
  90.     
  91.     //  Open Dispatch for both main and secondary queues
  92.     
  93.     OpenDispatch(kNoOfMessages);
  94.     secQPtr->OpenDispatch(kNoOfMessages);
  95.  
  96.     // In main queue wait for N/2 message codes in N completion routine invocations
  97.  
  98.     for (i = 0; i < N/2; i++) {
  99.         SpecialReceive(OS_MATCH_ALL, OS_MATCH_ALL, i*2 + CODE_OFFSET, 0, MainReceive);
  100.     }
  101.     
  102.     // From secondary queue send N messages to the main queue
  103.     
  104.     for (i = 0; i < N; i++) {
  105.         msgPtr = secQPtr->GetMsg();
  106.         if (msgPtr) {
  107.             msgPtr->mCode = i*2 + CODE_OFFSET;
  108.             msgPtr->mTo = mainTID;
  109.             msgPtr->mOData[0] = TickCount();
  110.             secQPtr->Send(msgPtr);
  111.         }
  112.     }
  113.     
  114.     // Issue multiple receives for the reply messages in secondary queue
  115.  
  116.     secQPtr->Receive(OS_MATCH_ALL, mainTID, 1 + CODE_OFFSET, 0, SecReceive0);
  117.     
  118.     secQPtr->Receive(OS_MATCH_ALL, mainTID, 3 + CODE_OFFSET, 1, SecReceive1);
  119.     
  120.     secQPtr->Receive(OS_MATCH_ALL, mainTID, 5 + CODE_OFFSET, -1, SecReceive2);
  121.     
  122.     secQPtr->Receive(OS_MATCH_ALL, mainTID, 7 + CODE_OFFSET, 100, SecReceive3);
  123.     
  124.     if ((msgRecd[4] = secQPtr->Receive(OS_MATCH_ALL, mainTID, 9 + CODE_OFFSET, -1, 0)) == 0)
  125.         msgRecd[4] = (mMessage *)-1;
  126.     
  127.     if ((msgRecd[5] = secQPtr->Receive(OS_MATCH_ALL, mainTID, 11 + CODE_OFFSET, 100, 0)) == 0)
  128.         msgRecd[5] = (mMessage *)-1;
  129.     
  130.     index = 0;
  131.     
  132.     echoTID = Lookup_Task(object_name, type_name, GetNameTID(), &index);
  133.     printf("Echo TID for main thread %d\n", echoTID);
  134.     printf("Name manager TID for main thread %d\n", GetNameTID());
  135.     index = 0;
  136.     
  137.     echoTID = secQPtr->Lookup_Task(object_name, type_name, secQPtr->GetNameTID(), &index);
  138.     printf("Echo TID for secondary thread %d\n", echoTID);
  139.     printf("Name manager TID for secondary thread %d\n", secQPtr->GetNameTID());
  140.     
  141.     // wait for another N/2 messages codes
  142.     
  143.     for (i = N/2; i < N; i++) {
  144.         SpecialReceive(OS_MATCH_ALL, OS_MATCH_ALL, i*2 + CODE_OFFSET, 0, MainReceive);
  145.     }
  146.     
  147.     if ((msgRecd[6] = secQPtr->Receive(OS_MATCH_ALL, mainTID, 13 + CODE_OFFSET, -1, 0)) == 0)
  148.         msgRecd[6] = (mMessage *)-1;
  149.     
  150.     if ((msgRecd[7] = secQPtr->Receive(OS_MATCH_ALL, mainTID, 15 + CODE_OFFSET, -1, 0)) == 0)
  151.         msgRecd[7] = (mMessage *)-1;
  152.     
  153.     done = kFalse;
  154.     
  155.     // Now wait for all messages to be received by the secondary completion routines
  156.     
  157.     while (!done) {
  158.         done = kTrue;
  159.         for (i = 0; i < N; i++) {
  160.             if (!msgRecd[i]) {
  161.                 done = kFalse;
  162.             }
  163.         }
  164.     }
  165.     
  166.     //  Print out the messages codes and the times
  167.     
  168.     for (i = 0; i < N; i++) {
  169.         if (msgRecd[i] != -1) {
  170.             printf("Message %08X %d %d %d %d\n", msgRecd[i], msgRecd[i]->mCode, msgRecd[i]->mOData[0],
  171.                     msgRecd[i]->mOData[1], msgRecd[i]->mOData[2]);
  172.         } else {
  173.             printf("No message\n");
  174.         }
  175.     }
  176.     
  177.     //  Close dispatch for both main and secondary queues
  178.     
  179.     CloseDispatch();
  180.     secQPtr->CloseDispatch();
  181.     
  182.     echoTID = Lookup_Task(object_name, type_name, GetNameTID(), &index);
  183.     printf("Echo TID for main thread %d\n", echoTID);
  184.     printf("Name manager TID for main thread %d\n", GetNameTID());
  185.     index = 0;
  186.     
  187.     echoTID = secQPtr->Lookup_Task(object_name, type_name, secQPtr->GetNameTID(), &index);
  188.     printf("Echo TID for secondary thread %d\n", echoTID);
  189.     printf("Name manager TID for secondary thread %d\n", secQPtr->GetNameTID());
  190.     
  191.     //  Close both main and secondary queues
  192.     
  193.     CloseQueue();
  194.     secQPtr->CloseQueue();
  195.     
  196.     //  Destroy secondary queue
  197.     
  198.     DestroyQueue(secQPtr);
  199.     
  200.     printf("Good Bye!\n");
  201. }
  202.  
  203. // Invoked when a message is received by the main queue (invoked multiple times)
  204.  
  205. void MainReceive(mMessage *msgPtr)
  206. {
  207.     tid_type temp;
  208.     
  209.     // Swap TID
  210.     
  211.     temp = msgPtr->mFrom;
  212.     msgPtr->mFrom = msgPtr->mTo;
  213.     msgPtr->mTo = temp;
  214.     
  215.     msgPtr->mCode += 1;                // increment code to indicate it is a reply
  216.     
  217.     msgPtr->mOData[1] = TickCount();    // get the current time in mOData[1]
  218.     
  219.     Send(msgPtr);                    // send using the main Queue
  220. }        
  221.  
  222. // These N completion routines each invoked by the corresponday reply message
  223. //
  224. //  Reads the current time into mOData[2] and sets corresponding msgRecd and frees the message
  225.  
  226. void SecReceive0(mMessage *msgPtr)
  227. {
  228.     if (msgPtr) {
  229.         msgPtr->mOData[2] = TickCount();
  230.         msgRecd[0] = msgPtr;
  231.         secQPtr->FreeMsg(msgPtr);
  232.     }
  233.     else {
  234.         msgRecd[0] = (mMessage *)-1;
  235.     }
  236. }
  237.  
  238. void SecReceive1(mMessage *msgPtr)
  239. {
  240.     if (msgPtr) {
  241.         msgPtr->mOData[2] = TickCount();
  242.         msgRecd[1] = msgPtr;
  243.         secQPtr->FreeMsg(msgPtr);
  244.     }
  245.     else {
  246.         msgRecd[1] = (mMessage *)-1;
  247.     }
  248. }
  249.  
  250. void SecReceive2(mMessage *msgPtr)
  251. {
  252.     if (msgPtr) {
  253.         msgPtr->mOData[2] = TickCount();
  254.         msgRecd[2] = msgPtr;
  255.         secQPtr->FreeMsg(msgPtr);
  256.     }
  257.     else {
  258.         msgRecd[2] = (mMessage *)-1;
  259.     }
  260. }
  261.  
  262. void SecReceive3(mMessage *msgPtr)
  263. {
  264.     if (msgPtr) {
  265.         msgPtr->mOData[2] = TickCount();
  266.         msgRecd[3] = msgPtr;
  267.         secQPtr->FreeMsg(msgPtr);
  268.     }
  269.     else {
  270.         msgRecd[3] = (mMessage *)-1;
  271.     }
  272. }
  273.